Cosmic Ray Report
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a - b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.53s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a - c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b - c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.38s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 - sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type - " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type - " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for -: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a * b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides................F.........FF [100%]
================================== FAILURES ===================================
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
3 failed, 25 passed in 0.53s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a * c <= b or b + c <= a:
return "not a triangle"
# Classification by sides............................ [100%] 28 passed in 0.35s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b * c <= a:
return "not a triangle"
# Classification by sides............................ [100%] 28 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 * sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type * " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type * " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: can't multiply sequence by non-int of type 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: can'...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: can'...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: can'...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: can'...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.58s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a / b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a / c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b / c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.48s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 / sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.52s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type / " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type / " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for /: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a // b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a // c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b // c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 // sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type // " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type // " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for //: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.48s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a % b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a % c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFF.FFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
19 failed, 9 passed in 0.52s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b % c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFF.FF....FFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
15 failed, 13 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 % sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type % " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type % " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: not all arguments converted during string formatting
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: not ...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: not ...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: not ...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: not ...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a ** b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides................F.F.......FF [100%]
================================== FAILURES ===================================
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
4 failed, 24 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a ** c <= b or b + c <= a:
return "not a triangle"
# Classification by sides................F........... [100%]
================================== FAILURES ===================================
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
1 failed, 27 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b ** c <= a:
return "not a triangle"
# Classification by sides................F........... [100%]
================================== FAILURES ===================================
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
1 failed, 27 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 ** sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"timeout
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type ** " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ** " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a >> b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF......FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 5.1
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 5.0005
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a >> b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...
22 failed, 6 passed in 0.48s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a >> c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a >> c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b >> c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b >> c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.50s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF..FFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
16 failed, 12 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type >> " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type >> " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a << b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides..FF...FF.....FF..FFF...F.FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides0-not a triangle] ___________________
sides = (1, 2, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides4-not a triangle] ___________________
sides = (1, 10, 12), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 5.1
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 5.0005
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a << b <= c or a + c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...
12 failed, 16 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a << c <= b or b + c <= a:
return "not a triangle"
# Classification by sides..FF...FF.....FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a << c <= b or b + c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
10 failed, 18 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b << c <= a:
return "not a triangle"
# Classification by sides..FF...FF.....FFFFFF.....F.. [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b << c <= a:
^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides5-not a triangle] ___________________
sides = (5, 1, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...
11 failed, 17 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF..FFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
16 failed, 12 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type << " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type << " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a | b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFF...FF...F.FFFFFF......FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 5.1
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 5.0005
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a | b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...
15 failed, 13 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a | c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFF.FFF.....FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a | c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
14 failed, 14 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b | c <= a:
return "not a triangle"
# Classification by sidesFFFFF..FF.....FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b | c <= a:
^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type | " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type | " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a & b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFF.FFFFF.FFFFFFFFF......FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 5.1
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 5.0005
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a & b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...
20 failed, 8 passed in 0.53s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a & c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFF.FFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a & c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
19 failed, 9 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b & c <= a:
return "not a triangle"
# Classification by sidesFFFFF.FFF.FF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b & c <= a:
^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
16 failed, 12 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFF.FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
17 failed, 11 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type & " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type & " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a ^ b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFF.FFF.F.F.FFFFFF......FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 5.1
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:62:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 5.0005
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a ^ b <= c or a + c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...
18 failed, 10 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a ^ c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFF.FFF..FF.FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a ^ c <= b or b + c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
16 failed, 12 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b ^ c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFF..FFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
> if a + b <= c or a + c <= b or b ^ c <= a:
^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:5: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
18 failed, 10 passed in 0.50s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.50s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
- return triangle_type + " triangle"
+ return triangle_type ^ " triangle"
FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
> return triangle_type ^ " triangle"
^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'str' and 'str'
HW00b.py:21: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_Add, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 + sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_Mul, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 * sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_Div, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 / sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_FloorDiv, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 // sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_Mod, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 % sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_Pow, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 ** sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"timeout
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_RShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFF...FFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
17 failed, 11 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_LShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_BitOr, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_BitAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"F.FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
14 failed, 14 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Sub_BitXor, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FF.....FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
10 failed, 18 passed in 0.52s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Add, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]+2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Add, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]+2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"....F....FFF....FFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
8 failed, 20 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Add, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]+2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.55s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Sub, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]-2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"....F....FFF....FFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
8 failed, 20 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Sub, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]-2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Sub, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]-2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Mul, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]*2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Mul, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]*2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Mul, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]*2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Div, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]/2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.53s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Div, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]/2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Div, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]/2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_FloorDiv, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]//2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_FloorDiv, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]//2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_FloorDiv, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]//2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.47s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Mod, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]%2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"....F....FFF.....FFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Mod, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]%2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF.....FFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
6 failed, 22 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_Mod, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]%2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_RShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"F.FFF.FFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
18 failed, 10 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_RShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - ValueEr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - ValueEr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_RShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for >>: 'float' and 'int'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_LShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF..FFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
16 failed, 12 passed in 0.48s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_LShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E ValueError: negative shift count
HW00b.py:18: ValueError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - ValueEr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - ValueEr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_LShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for <<: 'float' and 'int'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitOr, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitOr, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitOr, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for |: 'float' and 'int'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".FFF.FFFFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
16 failed, 12 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitAnd, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF.F.FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
14 failed, 14 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitAnd, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".FFF.F.FF....FFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for &: 'float' and 'int'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitXor, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FFF..FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
14 failed, 14 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitXor, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'int' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'float'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceBinaryOperator_Pow_BitXor, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"..FF...FFFFF..FFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E TypeError: unsupported operand type(s) for ^: 'float' and 'int'
HW00b.py:18: TypeError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
13 failed, 15 passed in 0.47s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a != b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFF.F...................... [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
5 failed, 23 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a == b != c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFFF..FF.......FFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
11 failed, 17 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a != b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"....F..FFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
14 failed, 14 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b != c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".....F...FFFFFFF............ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
8 failed, 20 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c or a != c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"......F..FFFFFFF............ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
8 failed, 20 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a < b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFF.F...................... [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
5 failed, 23 passed in 0.38s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a == b < c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFF...FF.......FFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
10 failed, 18 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a < b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"....F..FFF..FFFFFFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
12 failed, 16 passed in 0.59s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b < c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".....F...F.FFFFF............ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
7 failed, 21 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c or a < c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"......F..F.FFFFF............ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
7 failed, 21 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a <= b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles".....F...................... [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
1 failed, 27 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a == b <= c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles".......FF.......FFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
6 failed, 22 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a <= b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".........F..FFFF............ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
5 failed, 23 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b <= c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".........F.FFFFF............ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
6 failed, 22 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c or a <= c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".........F.FFFFF............ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
6 failed, 22 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a > b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFF........................ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
4 failed, 24 passed in 0.34s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a == b > c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFFF....................... [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
5 failed, 23 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a > b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"....F..FF.FF....FFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
9 failed, 19 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b > c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".....F....F................. [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
2 failed, 26 passed in 0.36s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c or a > c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"......F...F................. [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
2 failed, 26 passed in 0.40s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a >= b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"............................ [100%] 28 passed in 0.34s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a == b >= c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"....F....................... [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
1 failed, 27 passed in 0.38s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a >= b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"..........FF................ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
2 failed, 26 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b >= c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"..........F................. [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
1 failed, 27 passed in 0.38s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c or a >= c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"..........F................. [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
1 failed, 27 passed in 0.36s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a is b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"............................ [100%] 28 passed in 0.31s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a == b is c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"............................ [100%] 28 passed in 0.33s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a is b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"............................ [100%] 28 passed in 0.37s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b is c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"............................ [100%] 28 passed in 0.35s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c or a is c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"............................ [100%] 28 passed in 0.29s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a is not b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFF.F...................... [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
5 failed, 23 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if a == b is not c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFFF..FF.......FFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
11 failed, 17 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a is not b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"....F..FFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
14 failed, 14 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b is not c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".....F...FFFFFFF............ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
8 failed, 20 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c or a is not c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"......F..FFFFFFF............ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ^ ^^
E + isosceles right triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'scalene triangle'
E
E - scalene triangle
E ? ^ ^^
E + isosceles triangle
E ? +++ ^ ^
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
8 failed, 20 passed in 0.47s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Lt_Eq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) == 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.38s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Lt_NotEq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) != 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFF...FFFF............ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
13 failed, 15 passed in 0.46s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_Lt_LtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) <= 1e-9:
triangle_type += " right"
return triangle_type + " triangle"............................ [100%] 28 passed in 0.31s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Lt_Gt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) > 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.47s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_Lt_GtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) >= 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.55s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a == 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.31s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b == 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.37s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 or c == 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b == c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides........................F.FF [100%]
================================== FAILURES ===================================
__________________ test_not_triangle[sides4-not a triangle] ___________________
sides = (1, 10, 12), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
3 failed, 25 passed in 0.41s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c == b or b + c <= a:
return "not a triangle"
# Classification by sides............................ [100%] 28 passed in 0.33s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b + c == a:
return "not a triangle"
# Classification by sides.........................F.. [100%]
================================== FAILURES ===================================
__________________ test_not_triangle[sides5-not a triangle] ___________________
sides = (5, 1, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...
1 failed, 27 passed in 0.36s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a != 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.39s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b != 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 or c != 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b != c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFFF....... [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides0-not a triangle] ___________________
sides = (1, 2, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...
21 failed, 7 passed in 0.49s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c != b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b + c != a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.43s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a < 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.34s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b < 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.37s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 or c < 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.35s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b < c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides....................F....... [100%]
================================== FAILURES ===================================
__________________ test_not_triangle[sides0-not a triangle] ___________________
sides = (1, 2, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...
1 failed, 27 passed in 0.38s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c < b or b + c <= a:
return "not a triangle"
# Classification by sides............................ [100%] 28 passed in 0.35s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b + c < a:
return "not a triangle"
# Classification by sides............................ [100%] 28 passed in 0.35s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a > 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b > 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.48s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 or c > 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b > c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFFF...F.FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides0-not a triangle] ___________________
sides = (1, 2, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides4-not a triangle] ___________________
sides = (1, 10, 12), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
24 failed, 4 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c > b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b + c > a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF.....F.. [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides5-not a triangle] ___________________
sides = (5, 1, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...
21 failed, 7 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a >= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b >= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 or c >= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b >= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF....F.FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides4-not a triangle] ___________________
sides = (1, 10, 12), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
23 failed, 5 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c >= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b + c >= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF.....F.. [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides5-not a triangle] ___________________
sides = (5, 1, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...
21 failed, 7 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Is, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b is c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides........................F.FF [100%]
================================== FAILURES ===================================
__________________ test_not_triangle[sides4-not a triangle] ___________________
sides = (1, 10, 12), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
3 failed, 25 passed in 0.37s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceComparisonOperator_LtE_Is, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c is b or b + c <= a:
return "not a triangle"
# Classification by sides............................ [100%] 28 passed in 0.35s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_Is, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b + c is a:
return "not a triangle"
# Classification by sides.........................F.. [100%]
================================== FAILURES ===================================
__________________ test_not_triangle[sides5-not a triangle] ___________________
sides = (5, 1, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...
1 failed, 27 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_IsNot, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b is not c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFFF....... [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides0-not a triangle] ___________________
sides = (1, 2, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...
21 failed, 7 passed in 0.47s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_IsNot, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c is not b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceComparisonOperator_LtE_IsNot, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b or b + c is not a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.46s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/AddNot, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if not a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/AddNot, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if not a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sidesFFFFFFFFFFFFFFFFFFFFF...F.FF [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + not a triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + not a triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'scalene triangle'
E
E - scalene triangle
E + not a triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
__________________ test_not_triangle[sides0-not a triangle] ___________________
sides = (1, 2, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides4-not a triangle] ___________________
sides = (1, 10, 12), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
24 failed, 4 passed in 0.45s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/AddNot, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
return "not a triangle"
# Classification by sides
- if a == b == c:
+ if not a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + isosceles triangle
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + equilateral triangle
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + equilateral right triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + equilateral right triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'scalene right triangle'
E
E - scalene right triangle
E + equilateral right triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'scalene triangle'
E
E - scalene triangle
E + equilateral triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'scalene triangle'
E
E - scalene triangle
E + equilateral triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'scalene triangle'
E
E - scalene triangle
E + equilateral triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral triangle' == 'scalene triangle'
E
E - scalene triangle
E + equilateral triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + equilateral right triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/AddNot, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if not abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'
E
E - equilateral triangle
E + equilateral right triangle
E ? ++++++
test_HW00b.py:13: AssertionError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'scalene triangle'
E
E - scalene triangle
E + scalene right triangle
E ? ++++++
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.44s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceOrWithAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 and b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.33s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/ReplaceOrWithAnd, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 and c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.31s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceOrWithAnd, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c and a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides....................F...F.FF [100%]
================================== FAILURES ===================================
__________________ test_not_triangle[sides0-not a triangle] ___________________
sides = (1, 2, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides4-not a triangle] ___________________
sides = (1, 10, 12), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides6-not a triangle] ___________________
sides = (2.5, 2.5, 5.1), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
__________________ test_not_triangle[sides7-not a triangle] ___________________
sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'not a triangle'
E
E - not a triangle
E + isosceles triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...
FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...
4 failed, 24 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceOrWithAnd, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
- if a + b <= c or a + c <= b or b + c <= a:
+ if a + b <= c or a + c <= b and b + c <= a:
return "not a triangle"
# Classification by sides.........................F.. [100%]
================================== FAILURES ===================================
__________________ test_not_triangle[sides5-not a triangle] ___________________
sides = (5, 1, 3), expected = 'not a triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 2, 3), "not a triangle"),
((0, 4, 5), "not a triangle"),
((-1, 4, 5), "not a triangle"),
((0, 0, 0), "not a triangle"),
((1, 10, 12), "not a triangle"),
((5, 1, 3), "not a triangle"),
((2.5, 2.5, 5.1), "not a triangle"),
((2.5002, 2.5002, 5.0005), "not a triangle"),
])
def test_not_triangle(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'not a triangle'
E
E - not a triangle
E + scalene triangle
test_HW00b.py:62: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...
1 failed, 27 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceOrWithAnd, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b and b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"....FF.FF.......FFFF........ [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? --- ^ ^
E + scalene right triangle
E ? ^ ^^
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
8 failed, 20 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/ReplaceOrWithAnd, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
- elif a == b or b == c or a == c:
+ elif a == b or b == c and a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene".....FF..................... [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'isosceles triangle'
E
E - isosceles triangle
E ? --- ^ ^
E + scalene triangle
E ? ^ ^^
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
2 failed, 26 passed in 0.43s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 1 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"................F........... [100%]
================================== FAILURES ===================================
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
1 failed, 27 passed in 0.38s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/NumberReplacer, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= -1 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.36s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 1 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"................F........... [100%]
================================== FAILURES ===================================
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'not a triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E + not a triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
1 failed, 27 passed in 0.36s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/NumberReplacer, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= -1 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.32s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/NumberReplacer, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 or c <= 1:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.31s
SURVIVED
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.SURVIVED
operator: core/NumberReplacer, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
- if a <= 0 or b <= 0 or c <= 0:
+ if a <= 0 or b <= 0 or c <= -1:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"............................ [100%] 28 passed in 0.31s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 6
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[ 1]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF................ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
3 failed, 25 passed in 0.36s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 7
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[ -1]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.38s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 8
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]** 3 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF.....FFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
6 failed, 22 passed in 0.35s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 9
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]** 1 + sides[1]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF.....FFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
6 failed, 22 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 10
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[ 2]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 11
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[ 0]**2 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF................ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
3 failed, 25 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 12
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]** 3 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF.....FFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
6 failed, 22 passed in 0.41s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 13
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]** 1 - sides[2]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF.....FFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
6 failed, 22 passed in 0.42s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 14
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle"FFFFFFFFFFFFFFFFFFFF........ [100%]
================================== FAILURES ===================================
________________ test_equilateral[sides0-equilateral triangle] ________________
sides = (3, 3, 3), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
________________ test_equilateral[sides1-equilateral triangle] ________________
sides = (5, 5, 5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 5, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
________________ test_equilateral[sides2-equilateral triangle] ________________
sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 2.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
________________ test_equilateral[sides3-equilateral triangle] ________________
sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 3), "equilateral triangle"),
((5, 5, 5), "equilateral triangle"),
#((0, 0, 0), "equilateral triangle"), # fail
#((-1, -1, -1), "equilateral triangle"), # fail
((2.5, 2.5, 2.5), "equilateral triangle"),
((2.5002, 2.5002, 2.5002), "equilateral triangle"),
])
def test_equilateral(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:13:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 2.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
__________________ test_isosceles[sides0-isosceles triangle] __________________
sides = (3, 3, 2), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 2
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
__________________ test_isosceles[sides1-isosceles triangle] __________________
sides = (5, 8, 8), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 8, c = 8
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 7, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 2.5, c = 3.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:24:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 4, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 4, c = 3
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 4, b = 3, c = 5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________________ test_scalene[sides3-scalene triangle] ____________________
sides = (5, 6, 7), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 5, b = 6, c = 7
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________________ test_scalene[sides4-scalene triangle] ____________________
sides = (7, 8, 9), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 7, b = 8, c = 9
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________________ test_scalene[sides5-scalene triangle] ____________________
sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5, b = 3.5, c = 4.5
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________________ test_scalene[sides6-scalene triangle] ____________________
sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:37:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 3.5002, c = 4.5002
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1, b = 1, c = 1.4142135623730951
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 3, b = 3, c = 4.242640687119285
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 1.5, b = 1.5, c = 2.1213203435596424
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
^^^^^^^^^^^^^^^^^^^^^^^^^
test_HW00b.py:48:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
a = 2.5002, b = 2.5002, c = 3.535816748645212
def classify_triangle(a: float, b: float, c: float) -> str:
# Check validity
if a <= 0 or b <= 0 or c <= 0:
return "not a triangle"
if a + b <= c or a + c <= b or b + c <= a:
return "not a triangle"
# Classification by sides
if a == b == c:
triangle_type = "equilateral"
elif a == b or b == c or a == c:
triangle_type = "isosceles"
else:
triangle_type = "scalene"
# Right triangle check
sides = sorted([a, b, c])
> if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
^^^^^^^^^
E IndexError: list index out of range
HW00b.py:18: IndexError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - IndexEr...
FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - IndexEr...
FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - IndexEr...
FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - IndexEr...
FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - IndexError:...
FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - IndexError:...
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - IndexError:...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - IndexError:...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - IndexError:...
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - IndexErro...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - IndexErro...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - IndexErro...
FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - IndexError: lis...
FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - IndexError: lis...
FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - IndexError: lis...
FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - IndexError: lis...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
20 failed, 8 passed in 0.40s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 15
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[ 1]**2) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.34s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 16
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]** 3) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 17
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]** 1) < 1e-9:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.44s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 18
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1.000000001:
triangle_type += " right"
return triangle_type + " triangle"......FFF................... [100%]
================================== FAILURES ===================================
__________________ test_isosceles[sides2-isosceles triangle] __________________
sides = (5, 7, 5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides3-isosceles triangle] __________________
sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
__________________ test_isosceles[sides4-isosceles triangle] __________________
sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 3, 2), "isosceles triangle"),
((5, 8, 8), "isosceles triangle"),
((5, 7, 5), "isosceles triangle"),
((2.5, 2.5, 3.5), "isosceles triangle"),
((2.5002, 2.5002, 3.5002), "isosceles triangle"),
])
def test_isosceles(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'
E
E - isosceles triangle
E + isosceles right triangle
E ? ++++++
test_HW00b.py:24: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...
FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...
3 failed, 25 passed in 0.37s
worker outcome: WorkerOutcome.NORMAL
test outcome: TestOutcome.KILLED
operator: core/NumberReplacer, occurrence: 19
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
# Right triangle check
sides = sorted([a, b, c])
- if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+ if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < -0.999999999:
triangle_type += " right"
return triangle_type + " triangle".........FFF....FFFF........ [100%]
================================== FAILURES ===================================
_________________ test_scalene[sides0-scalene right triangle] _________________
sides = (3, 4, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides1-scalene right triangle] _________________
sides = (5, 4, 3), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
_________________ test_scalene[sides2-scalene right triangle] _________________
sides = (4, 3, 5), expected = 'scalene right triangle'
@pytest.mark.parametrize("sides, expected", [
((3, 4, 5), "scalene right triangle"),
((5, 4, 3), "scalene right triangle"),
((4, 3, 5), "scalene right triangle"),
((5, 6, 7), "scalene triangle"),
((7, 8, 9), "scalene triangle"),
((2.5, 3.5, 4.5), "scalene triangle"),
((2.5002, 3.5002, 4.5002), "scalene triangle"),
])
def test_scalene(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'scalene triangle' == 'scalene right triangle'
E
E - scalene right triangle
E ? ------
E + scalene triangle
test_HW00b.py:37: AssertionError
____________ test_isosceles_right[sides0-isosceles right triangle] ____________
sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides1-isosceles right triangle] ____________
sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides2-isosceles right triangle] ____________
sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
____________ test_isosceles_right[sides3-isosceles right triangle] ____________
sides = (2.5002, 2.5002, 3.535816748645212)
expected = 'isosceles right triangle'
@pytest.mark.parametrize("sides, expected", [
((1, 1, 2**0.5), "isosceles right triangle"),
#((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail
((3, 3, (2*3**2)**0.5), "isosceles right triangle"),
((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),
((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),
])
def test_isosceles_right(sides, expected):
> assert classify_triangle(*sides) == expected
E AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'
E
E - isosceles right triangle
E ? ------
E + isosceles triangle
test_HW00b.py:48: AssertionError
=========================== short test summary info ===========================
FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...
FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]
FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]
7 failed, 21 passed in 0.39s